package com.hp.bon.sgw.snmp;

import org.snmp4j.agent.DuplicateRegistrationException;
import org.snmp4j.agent.MOGroup;
import org.snmp4j.agent.MOServer;
import org.snmp4j.agent.NotificationOriginator;
import org.snmp4j.agent.mo.DefaultMOFactory;
import org.snmp4j.agent.mo.DefaultMOMutableRow2PC;
import org.snmp4j.agent.mo.DefaultMOMutableRow2PCFactory;
import org.snmp4j.agent.mo.MOAccessImpl;
import org.snmp4j.agent.mo.MOColumn;
import org.snmp4j.agent.mo.MOFactory;
import org.snmp4j.agent.mo.MOMutableTableModel;
import org.snmp4j.agent.mo.MOScalar;
import org.snmp4j.agent.mo.MOTable;
import org.snmp4j.agent.mo.MOTableIndex;
import org.snmp4j.agent.mo.MOTableIndexValidator;
import org.snmp4j.agent.mo.MOTableModel;
import org.snmp4j.agent.mo.MOTableSubIndex;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.Counter32;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.SMIConstants;
import org.snmp4j.smi.Variable;
import org.snmp4j.smi.VariableBinding;

public class SgwMib
  implements MOGroup
{
  private static final LogAdapter LOGGER = LogFactory.getLogger(SgwMib.class);

  private MOFactory moFactory = DefaultMOFactory.getInstance();

  public static final OID oidSgwMib = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 1 });

  public static final OID oidNeid = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 1, 1, 1 });

  public static final OID oidSgwid = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 1, 1, 2 });

  public static final OID oidNename = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 1, 1, 3 });

  public static final OID oidDeployaddr = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 1, 1, 4 });

  public static final OID oidNEVendorName = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 1, 1, 5 });

  public static final OID oidNeversion = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 1, 1, 6 });

  public static final OID oidNodeId = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 1, 1, 7 });

  public static final OID oidSgwbsnstate = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 2, 1, 2 });

  public static final OID oidSgwnestate = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 2, 1, 3 });

  public static final OID oidSgwsysuptime = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 2, 1, 4 });

  public static final OID oidSgwconlevel = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 2, 1, 5 });

  public static final OID oidNeCpuRate = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 2, 2, 1, 1 });

  public static final OID oidNeMemRate = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 2, 2, 1, 2 });

  public static final OID oidNeQueSize = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 2, 2, 1, 3 });

  public static final OID oidNeQueRate = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 2, 2, 1, 4 });

  public static final OID oidFileresult = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 3, 1, 2, 2 });

  public static final OID oidFileupdatetime = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 2, 3 });

  public static final OID oidMaxconnections = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 1, 2 });

  public static final OID oidLinkalertupdatetime = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 1, 3 });

  public static final OID oidOldlevel = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 3, 2, 3, 2 });

  public static final OID oidNewlevel = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 3, 2, 3, 3 });

  public static final OID oidLevelupdatetime = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 3, 4 });

  public static final OID oidSGWStatesChanged = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 2, 1, 1 });

  public static final OID oidTrapVarNeid = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 1, 1, 1 });

  public static final OID oidTrapVarSgwid = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 1, 1, 2 });

  public static final OID oidTrapVarNename = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 1, 1, 3 });

  public static final OID oidTrapVarDeployaddr = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 1, 1, 4 });

  public static final OID oidTrapVarNEVendorName = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 1, 1, 5 });

  public static final OID oidTrapVarNeversion = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 1, 1, 6 });

  public static final OID oidTrapVarNodeId = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 1, 1, 7 });

  public static final OID oidTrapVarSgwbsnstate = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 2, 1, 2 });

  public static final OID oidTrapVarSgwnestate = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 2, 1, 3 });

  public static final OID oidTrapVarSgwsysuptime = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 2, 1, 4 });

  public static final OID oidMsgErrorNotify = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 1, 1 });

  public static final OID oidTrapVarMsgtype = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 1, 2, 1, 1 });

  public static final OID oidTrapVarMsgerrresult = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 1, 2, 1, 2 });

  public static final OID oidTrapVarMsgupdatetime = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 1, 2, 1, 3 });

  public static final OID oidFileErrorNotify = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 2, 1 });

  public static final OID oidTrapVarFileresult = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 2, 2 });

  public static final OID oidTrapVarFileupdatetime = new OID(new int[] { 1, 
    3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 2, 3 });

  public static final OID oidInterfaceConnectsCntMaxNotify = new OID(
    new int[] { 1, 3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 1, 1 });

  public static final OID oidTrapVarMaxconnections = new OID(new int[] { 1, 
    3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 1, 2 });

  public static final OID oidTrapVarLinkalertupdatetime = new OID(new int[] { 
    1, 3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 1, 3 });

  public static final OID oidFlowSizeAlertNotify = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 1 });

  public static final OID oidTrapVarFlowalertnecode = new OID(new int[] { 1, 
    3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 1 });

  public static final OID oidTrapVarFlowalertuser = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 2 });

  public static final OID oidTrapVarFLOWALERTCapability = new OID(new int[] { 
    1, 3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 3 });

  public static final OID oidTrapVarFLOWALERTFLOWCount = new OID(new int[] { 
    1, 3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 4 });

  public static final OID oidTrapVarFlowalertflowszie = new OID(new int[] { 
    1, 3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 5 });

  public static final OID oidTrapVarAlertreason = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 6 });

  public static final OID oidTrapVarFlowalertupdatetime = new OID(new int[] { 
    1, 3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 7 });

  public static final OID oidBlockChangedNotify = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 3, 1 });

  public static final OID oidTrapVarOldlevel = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 3, 2 });

  public static final OID oidTrapVarNewlevel = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 3, 3 });

  public static final OID oidTrapVarLevelupdatetime = new OID(new int[] { 1, 
    3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 3, 4 });

  public static final OID oidInterfaceRunningErrorNotify = new OID(new int[] { 
    1, 3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 3, 1, 1 });

  public static final OID oidTrapVarLinknecode = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 3, 1, 2, 1, 1 });

  public static final OID oidTrapVarLinkstate = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 3, 1, 2, 1, 2 });

  public static final OID oidTrapVarLinkstatedesc = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 3, 1, 2, 1, 3 });

  public static final OID oidTrapVarLinkupdatetime = new OID(new int[] { 1, 
    3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 3, 1, 2, 1, 4 });
  private static final String TC_MODULE_SNMPV2_TC = "SNMPv2-TC";
  private static final String TC_DISPLAYSTRING = "DisplayString";
  private MOScalar<Counter32> neid;
  private MOScalar<Counter32> sgwid;
  private MOScalar<OctetString> nename;
  private MOScalar<OctetString> deployaddr;
  private MOScalar<OctetString> nEVendorName;
  private MOScalar<OctetString> neversion;
  private MOScalar<OctetString> nodeId;
  private MOScalar<Counter32> sgwbsnstate;
  private MOScalar<Counter32> sgwnestate;
  private MOScalar<Counter32> sgwsysuptime;
  private MOScalar<Counter32> sgwconlevel;
  private MOScalar<OctetString> neCpuRate;
  private MOScalar<OctetString> neMemRate;
  private MOScalar<Counter32> neQueSize;
  private MOScalar<Counter32> neQueRate;
  private MOScalar<OctetString> fileresult;
  private MOScalar<Counter32> fileupdatetime;
  private MOScalar<Counter32> maxconnections;
  private MOScalar<Counter32> linkalertupdatetime;
  private MOScalar<Counter32> oldlevel;
  private MOScalar<Counter32> newlevel;
  private MOScalar<Counter32> levelupdatetime;
  public static final OID oidProtocolInfoEntry = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 1, 2, 1 });

  public static final OID oidProtocolcode = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 1, 2, 1, 1 });
  public static final String tcModuleSNMPv2Tc = "SNMPv2-TC";
  public static final String tcDefDisplayString = "DisplayString";
  public static final int colProtocolcode = 1;
  public static final int colProtocolname = 2;
  public static final int colProtocolversion = 3;
  public static final int colProtocoldesc = 4;
  public static final int colTimeoutLinkWait = 5;
  public static final int idxProtocolcode = 0;
  public static final int idxProtocolname = 1;
  public static final int idxProtocolversion = 2;
  public static final int idxProtocoldesc = 3;
  public static final int idxTimeoutLinkWait = 4;
  private MOTableSubIndex[] protocolInfoEntryIndexes;
  private MOTableIndex protocolInfoEntryIndex;
  private MOTable<ProtocolInfoEntryRow, MOColumn, MOTableModel<ProtocolInfoEntryRow>> protocolInfoEntry;
  private MOTableModel<ProtocolInfoEntryRow> protocolInfoEntryModel;
  public static final OID oidServiceInfoEntry = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 1, 3, 1 });

  public static final OID oidServiceid = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 1, 3, 1, 1 });
  public static final int colServiceid = 1;
  public static final int colCapabilitycode = 2;
  public static final int colServicename = 3;
  public static final int colServicedesc = 4;
  public static final int idxServiceid = 0;
  public static final int idxCapabilitycode = 1;
  public static final int idxServicename = 2;
  public static final int idxServicedesc = 3;
  private MOTableSubIndex[] serviceInfoEntryIndexes;
  private MOTableIndex serviceInfoEntryIndex;
  private MOTable<ServiceInfoEntryRow, MOColumn, MOTableModel<ServiceInfoEntryRow>> serviceInfoEntry;
  private MOTableModel<ServiceInfoEntryRow> serviceInfoEntryModel;
  public static final OID oidUserInfoEntry = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 1, 4, 1 });

  public static final OID oidCfgusercode = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 1, 4, 1, 1 });
  public static final int colCfgusercode = 1;
  public static final int colCfgusername = 2;
  public static final int colCfgnename = 3;
  public static final int colCfgnedesc = 4;
  public static final int idxCfgusercode = 0;
  public static final int idxCfgusername = 1;
  public static final int idxCfgnename = 2;
  public static final int idxCfgnedesc = 3;
  private MOTableSubIndex[] userInfoEntryIndexes;
  private MOTableIndex userInfoEntryIndex;
  private MOTable<UserInfoEntryRow, MOColumn, MOTableModel<UserInfoEntryRow>> userInfoEntry;
  private MOTableModel<UserInfoEntryRow> userInfoEntryModel;
  public static final OID oidUserServInfoEntry = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 1, 5, 1 });

  public static final OID oidSvrusercode = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 1, 5, 1, 2 });
  public static final int colUseSvIdID = 1;
  public static final int colSvrusercode = 2;
  public static final int colUsercapabilitycode = 3;
  public static final int idxUseSvIdID = 0;
  public static final int idxSvrusercode = 1;
  public static final int idxUsercapabilitycode = 2;
  private MOTableSubIndex[] userServInfoEntryIndexes;
  private MOTableIndex userServInfoEntryIndex;
  private MOTable<UserServInfoEntryRow, MOColumn, MOTableModel<UserServInfoEntryRow>> userServInfoEntry;
  private MOTableModel<UserServInfoEntryRow> userServInfoEntryModel;
  public static final OID oidRouteInfoEntry = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 1, 6, 1 });

  public static final OID oidSrid = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 1, 6, 1, 1 });
  public static final int colSrid = 1;
  public static final int colIp = 2;
  public static final int colPort = 3;
  public static final int colName = 4;
  public static final int colRealm = 5;
  public static final int idxSrid = 0;
  public static final int idxIp = 1;
  public static final int idxPort = 2;
  public static final int idxName = 3;
  public static final int idxRealm = 4;
  private MOTableSubIndex[] routeInfoEntryIndexes;
  private MOTableIndex routeInfoEntryIndex;
  private MOTable<RouteInfoEntryRow, MOColumn, MOTableModel<RouteInfoEntryRow>> routeInfoEntry;
  private MOTableModel<RouteInfoEntryRow> routeInfoEntryModel;
  public static final OID oidProcResourceUsedEntry = new OID(new int[] { 1, 
    3, 6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 2, 2, 2, 1 });

  public static final OID oidPid = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 2, 2, 2, 1, 1 });
  public static final int colPid = 1;
  public static final int colPname = 2;
  public static final int colPCpuRate = 3;
  public static final int colPMemRate = 4;
  public static final int idxPid = 0;
  public static final int idxPname = 1;
  public static final int idxPCpuRate = 2;
  public static final int idxPMemRate = 3;
  private MOTableSubIndex[] procResourceUsedEntryIndexes;
  private MOTableIndex procResourceUsedEntryIndex;
  private MOTable<ProcResourceUsedEntryRow, MOColumn, MOTableModel<ProcResourceUsedEntryRow>> procResourceUsedEntry;
  private MOTableModel<ProcResourceUsedEntryRow> procResourceUsedEntryModel;
  public static final OID oidMsgAlarmEntry = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 3, 1, 1, 2, 1 });

  public static final OID oidMsgtype = new OID(new int[] { 1, 3, 6, 1, 4, 1, 
    81000, 2, 103, 2, 2, 2, 3, 1, 1, 2, 1, 1 });
  public static final int colMsgtype = 1;
  public static final int colMsgerrresult = 2;
  public static final int colMsgupdatetime = 3;
  public static final int idxMsgtype = 0;
  public static final int idxMsgerrresult = 1;
  public static final int idxMsgupdatetime = 2;
  private MOTableSubIndex[] msgAlarmEntryIndexes;
  private MOTableIndex msgAlarmEntryIndex;
  private MOTable<MsgAlarmEntryRow, MOColumn, MOTableModel<MsgAlarmEntryRow>> msgAlarmEntry;
  private MOTableModel<MsgAlarmEntryRow> msgAlarmEntryModel;
  public static final OID oidFlowAlarmEntry = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1 });

  public static final OID oidFlowalertnecode = new OID(new int[] { 1, 3, 6, 
    1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 1 });

  public static final OID oidFlowalertuser = new OID(new int[] { 1, 3, 6, 1, 
    4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 2 });

  public static final OID oidFLOWALERTCapability = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 2, 2, 2, 1, 3 });
  public static final int colFlowalertnecode = 1;
  public static final int colFlowalertuser = 2;
  public static final int colFLOWALERTCapability = 3;
  public static final int colFLOWALERTFLOWCount = 4;
  public static final int colFlowalertflowszie = 5;
  public static final int colAlertreason = 6;
  public static final int colFlowalertupdatetime = 7;
  public static final int idxFlowalertnecode = 0;
  public static final int idxFlowalertuser = 1;
  public static final int idxFLOWALERTCapability = 2;
  public static final int idxFLOWALERTFLOWCount = 3;
  public static final int idxFlowalertflowszie = 4;
  public static final int idxAlertreason = 5;
  public static final int idxFlowalertupdatetime = 6;
  private MOTableSubIndex[] flowAlarmEntryIndexes;
  private MOTableIndex flowAlarmEntryIndex;
  private MOTable<FlowAlarmEntryRow, MOColumn, MOTableModel<FlowAlarmEntryRow>> flowAlarmEntry;
  private MOTableModel<FlowAlarmEntryRow> flowAlarmEntryModel;
  public static final OID oidOutNeLinkAlarmEntry = new OID(new int[] { 1, 3, 
    6, 1, 4, 1, 81000, 2, 103, 2, 2, 2, 3, 3, 1, 2, 1 });

  public static final OID oidLinknecode = new OID(new int[] { 1, 3, 6, 1, 4, 
    1, 81000, 2, 103, 2, 2, 2, 3, 3, 1, 2, 1, 1 });
  public static final int colLinknecode = 1;
  public static final int colLinkstate = 2;
  public static final int colLinkstatedesc = 3;
  public static final int colLinkupdatetime = 4;
  public static final int idxLinknecode = 0;
  public static final int idxLinkstate = 1;
  public static final int idxLinkstatedesc = 2;
  public static final int idxLinkupdatetime = 3;
  private MOTableSubIndex[] outNeLinkAlarmEntryIndexes;
  private MOTableIndex outNeLinkAlarmEntryIndex;
  private MOTable<OutNeLinkAlarmEntryRow, MOColumn, MOTableModel<OutNeLinkAlarmEntryRow>> outNeLinkAlarmEntry;
  private MOTableModel<OutNeLinkAlarmEntryRow> outNeLinkAlarmEntryModel;

  protected SgwMib()
  {
  }

  public SgwMib(MOFactory moFactory)
  {
    this();
    createMO(moFactory);
  }

	// --AgentGen BEGIN=_CONSTRUCTORS
	// --AgentGen END

	/**
	 * Create the ManagedObjects defined for this MIB module using the specified
	 * {@link MOFactory}.
	 * 
	 * @param moFactory
	 *            the <code>MOFactory</code> instance to use for object
	 *            creation.
	 */
	protected void createMO(MOFactory moFactory) {
		addTCsToFactory(moFactory);
		neid = moFactory.createScalar(oidNeid,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		sgwid = moFactory.createScalar(oidSgwid,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		nename = moFactory.createScalar(oidNename,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				null, TC_MODULE_SNMPV2_TC, TC_DISPLAYSTRING);
		deployaddr = moFactory.createScalar(oidDeployaddr,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				null, TC_MODULE_SNMPV2_TC, TC_DISPLAYSTRING);
		nEVendorName = moFactory.createScalar(oidNEVendorName,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				null, TC_MODULE_SNMPV2_TC, TC_DISPLAYSTRING);
		neversion = moFactory.createScalar(oidNeversion,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				null, TC_MODULE_SNMPV2_TC, TC_DISPLAYSTRING);
		nodeId = moFactory.createScalar(oidNodeId,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				null, TC_MODULE_SNMPV2_TC, TC_DISPLAYSTRING);
		sgwbsnstate = moFactory.createScalar(oidSgwbsnstate,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		sgwnestate = moFactory.createScalar(oidSgwnestate,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		sgwsysuptime = moFactory.createScalar(oidSgwsysuptime,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		sgwconlevel = moFactory.createScalar(oidSgwconlevel,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		neCpuRate = moFactory.createScalar(oidNeCpuRate,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				null, TC_MODULE_SNMPV2_TC, TC_DISPLAYSTRING);
		neMemRate = moFactory.createScalar(oidNeMemRate,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				null, TC_MODULE_SNMPV2_TC, TC_DISPLAYSTRING);
		neQueSize = moFactory.createScalar(oidNeQueSize,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		neQueRate = moFactory.createScalar(oidNeQueRate,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		fileresult = moFactory.createScalar(oidFileresult,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				null, TC_MODULE_SNMPV2_TC, TC_DISPLAYSTRING);
		fileupdatetime = moFactory.createScalar(oidFileupdatetime,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		maxconnections = moFactory.createScalar(oidMaxconnections,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		linkalertupdatetime = moFactory.createScalar(oidLinkalertupdatetime,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		oldlevel = moFactory.createScalar(oidOldlevel,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		newlevel = moFactory.createScalar(oidNewlevel,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		levelupdatetime = moFactory.createScalar(oidLevelupdatetime,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				new Counter32());
		createProtocolInfoEntry(moFactory);
		createServiceInfoEntry(moFactory);
		createUserInfoEntry(moFactory);
		createUserServInfoEntry(moFactory);
		createRouteInfoEntry(moFactory);
		createProcResourceUsedEntry(moFactory);
		createMsgAlarmEntry(moFactory);
		createFlowAlarmEntry(moFactory);
		createOutNeLinkAlarmEntry(moFactory);
	}

  public MOScalar<Counter32> getNeid() {
    return this.neid;
  }

  public MOScalar<Counter32> getSgwid() {
    return this.sgwid;
  }

  public MOScalar<OctetString> getNename() {
    return this.nename;
  }

  public MOScalar<OctetString> getDeployaddr() {
    return this.deployaddr;
  }

  public MOScalar<OctetString> getNEVendorName() {
    return this.nEVendorName;
  }

  public MOScalar<OctetString> getNeversion() {
    return this.neversion;
  }

  public MOScalar<OctetString> getNodeId() {
    return this.nodeId;
  }

  public MOScalar<Counter32> getSgwbsnstate() {
    return this.sgwbsnstate;
  }

  public MOScalar<Counter32> getSgwnestate() {
    return this.sgwnestate;
  }

  public MOScalar<Counter32> getSgwsysuptime() {
    return this.sgwsysuptime;
  }

  public MOScalar<Counter32> getSgwconlevel() {
    return this.sgwconlevel;
  }

  public MOScalar<OctetString> getNeCpuRate() {
    return this.neCpuRate;
  }

  public MOScalar<OctetString> getNeMemRate() {
    return this.neMemRate;
  }

  public MOScalar<Counter32> getNeQueSize() {
    return this.neQueSize;
  }

  public MOScalar<Counter32> getNeQueRate() {
    return this.neQueRate;
  }

  public MOScalar<OctetString> getFileresult() {
    return this.fileresult;
  }

  public MOScalar<Counter32> getFileupdatetime() {
    return this.fileupdatetime;
  }

  public MOScalar<Counter32> getMaxconnections() {
    return this.maxconnections;
  }

  public MOScalar<Counter32> getLinkalertupdatetime() {
    return this.linkalertupdatetime;
  }

  public MOScalar<Counter32> getOldlevel() {
    return this.oldlevel;
  }

  public MOScalar<Counter32> getNewlevel() {
    return this.newlevel;
  }

  public MOScalar<Counter32> getLevelupdatetime() {
    return this.levelupdatetime;
  }

  public MOTable<ProtocolInfoEntryRow, MOColumn, MOTableModel<ProtocolInfoEntryRow>> getProtocolInfoEntry() {
    return this.protocolInfoEntry;
  }

  private void createProtocolInfoEntry(MOFactory moFactory)
  {
    this.protocolInfoEntryIndexes = new MOTableSubIndex[] { moFactory
      .createSubIndex(oidProtocolcode, 2, 
      1, 1) };

		protocolInfoEntryIndex = moFactory.createIndex(
				protocolInfoEntryIndexes, false, new MOTableIndexValidator() {
					public boolean isValidIndex(OID index) {
						boolean isValidIndex = true;
						// --AgentGen BEGIN=protocolInfoEntry::isValidIndex
						// --AgentGen END
						return isValidIndex;
					}
				});

		// Columns
		MOColumn[] protocolInfoEntryColumns = new MOColumn[5];
		protocolInfoEntryColumns[idxProtocolcode] = moFactory.createColumn(
				colProtocolcode, SMIConstants.SYNTAX_COUNTER32,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
		protocolInfoEntryColumns[idxProtocolname] = moFactory.createColumn(
				colProtocolname, SMIConstants.SYNTAX_OCTET_STRING,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				tcModuleSNMPv2Tc, tcDefDisplayString);
		protocolInfoEntryColumns[idxProtocolversion] = moFactory.createColumn(
				colProtocolversion, SMIConstants.SYNTAX_OCTET_STRING,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				tcModuleSNMPv2Tc, tcDefDisplayString);
		protocolInfoEntryColumns[idxProtocoldesc] = moFactory.createColumn(
				colProtocoldesc, SMIConstants.SYNTAX_OCTET_STRING,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
				tcModuleSNMPv2Tc, tcDefDisplayString);
		protocolInfoEntryColumns[idxTimeoutLinkWait] = moFactory.createColumn(
				colTimeoutLinkWait, SMIConstants.SYNTAX_COUNTER32,
				moFactory.createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
		// Table model
		protocolInfoEntryModel = moFactory.createTableModel(
				oidProtocolInfoEntry, protocolInfoEntryIndex,
				protocolInfoEntryColumns);
		((MOMutableTableModel<ProtocolInfoEntryRow>) protocolInfoEntryModel)
				.setRowFactory(new ProtocolInfoEntryRowFactory());
		protocolInfoEntry = moFactory.createTable(oidProtocolInfoEntry,
				protocolInfoEntryIndex, protocolInfoEntryColumns,
				protocolInfoEntryModel);
	}

  public MOTable<ServiceInfoEntryRow, MOColumn, MOTableModel<ServiceInfoEntryRow>> getServiceInfoEntry() {
    return this.serviceInfoEntry;
  }

  private void createServiceInfoEntry(MOFactory moFactory)
  {
    this.serviceInfoEntryIndexes = new MOTableSubIndex[] { moFactory
      .createSubIndex(oidServiceid, 2, 1, 1) };

    this.serviceInfoEntryIndex = moFactory.createIndex(this.serviceInfoEntryIndexes, 
      false, new MOTableIndexValidator() {
      public boolean isValidIndex(OID index) {
        boolean isValidIndex = true;

        return isValidIndex;
      }
    });
    MOColumn[] serviceInfoEntryColumns = new MOColumn[4];
    serviceInfoEntryColumns[0] = moFactory.createColumn(
      1, 65, 
      moFactory.createAccess(9));
    serviceInfoEntryColumns[1] = moFactory.createColumn(
      2, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    serviceInfoEntryColumns[2] = moFactory.createColumn(
      3, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    serviceInfoEntryColumns[3] = moFactory.createColumn(
      4, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");

    this.serviceInfoEntryModel = moFactory.createTableModel(oidServiceInfoEntry, 
      this.serviceInfoEntryIndex, serviceInfoEntryColumns);
    ((MOMutableTableModel)this.serviceInfoEntryModel)
      .setRowFactory(new ServiceInfoEntryRowFactory());
    this.serviceInfoEntry = moFactory.createTable(oidServiceInfoEntry, 
      this.serviceInfoEntryIndex, serviceInfoEntryColumns, 
      this.serviceInfoEntryModel);
  }

  public MOTable<UserInfoEntryRow, MOColumn, MOTableModel<UserInfoEntryRow>> getUserInfoEntry() {
    return this.userInfoEntry;
  }

  private void createUserInfoEntry(MOFactory moFactory)
  {
    this.userInfoEntryIndexes = new MOTableSubIndex[] { moFactory
      .createSubIndex(oidCfgusercode, 
      4, 0, 255) };

    this.userInfoEntryIndex = moFactory.createIndex(this.userInfoEntryIndexes, false, 
      new MOTableIndexValidator() {
      public boolean isValidIndex(OID index) {
        boolean isValidIndex = true;

        return isValidIndex;
      }
    });
    MOColumn[] userInfoEntryColumns = new MOColumn[4];
    userInfoEntryColumns[0] = moFactory.createColumn(
      1, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    userInfoEntryColumns[1] = moFactory.createColumn(
      2, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    userInfoEntryColumns[2] = moFactory.createColumn(
      3, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    userInfoEntryColumns[3] = moFactory.createColumn(
      4, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");

    this.userInfoEntryModel = moFactory.createTableModel(oidUserInfoEntry, 
      this.userInfoEntryIndex, userInfoEntryColumns);
    ((MOMutableTableModel)this.userInfoEntryModel)
      .setRowFactory(new UserInfoEntryRowFactory());
    this.userInfoEntry = moFactory.createTable(oidUserInfoEntry, 
      this.userInfoEntryIndex, userInfoEntryColumns, this.userInfoEntryModel);
  }

  public MOTable<UserServInfoEntryRow, MOColumn, MOTableModel<UserServInfoEntryRow>> getUserServInfoEntry() {
    return this.userServInfoEntry;
  }

  private void createUserServInfoEntry(MOFactory moFactory)
  {
    this.userServInfoEntryIndexes = new MOTableSubIndex[] { moFactory
      .createSubIndex(oidSvrusercode, 
      4, 0, 255) };

    this.userServInfoEntryIndex = moFactory.createIndex(
      this.userServInfoEntryIndexes, false, new MOTableIndexValidator() {
      public boolean isValidIndex(OID index) {
        boolean isValidIndex = true;

        return isValidIndex;
      }
    });
    MOColumn[] userServInfoEntryColumns = new MOColumn[3];
    userServInfoEntryColumns[0] = moFactory.createColumn(
      1, 65, 
      moFactory.createAccess(9));
    userServInfoEntryColumns[1] = moFactory.createColumn(
      2, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    userServInfoEntryColumns[2] = moFactory
      .createColumn(
      3, 
      4, 
      moFactory
      .createAccess(9), 
      "SNMPv2-TC", "DisplayString");

    this.userServInfoEntryModel = moFactory.createTableModel(
      oidUserServInfoEntry, this.userServInfoEntryIndex, 
      userServInfoEntryColumns);
    ((MOMutableTableModel)this.userServInfoEntryModel)
      .setRowFactory(new UserServInfoEntryRowFactory());
    this.userServInfoEntry = moFactory.createTable(oidUserServInfoEntry, 
      this.userServInfoEntryIndex, userServInfoEntryColumns, 
      this.userServInfoEntryModel);
  }

  public MOTable<RouteInfoEntryRow, MOColumn, MOTableModel<RouteInfoEntryRow>> getRouteInfoEntry() {
    return this.routeInfoEntry;
  }

  private void createRouteInfoEntry(MOFactory moFactory)
  {
    this.routeInfoEntryIndexes = new MOTableSubIndex[] { moFactory
      .createSubIndex(oidSrid, 2, 1, 1) };

    this.routeInfoEntryIndex = moFactory.createIndex(this.routeInfoEntryIndexes, 
      false, new MOTableIndexValidator() {
      public boolean isValidIndex(OID index) {
        boolean isValidIndex = true;

        return isValidIndex;
      }
    });
    MOColumn[] routeInfoEntryColumns = new MOColumn[5];
    routeInfoEntryColumns[0] = moFactory.createColumn(1, 
      65, 
      moFactory.createAccess(9));
    routeInfoEntryColumns[1] = moFactory.createColumn(2, 
      4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    routeInfoEntryColumns[2] = moFactory.createColumn(3, 
      65, 
      moFactory.createAccess(9));
    routeInfoEntryColumns[3] = moFactory.createColumn(4, 
      4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    routeInfoEntryColumns[4] = moFactory.createColumn(5, 
      4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");

    this.routeInfoEntryModel = moFactory.createTableModel(oidRouteInfoEntry, 
      this.routeInfoEntryIndex, routeInfoEntryColumns);
    ((MOMutableTableModel)this.routeInfoEntryModel)
      .setRowFactory(new RouteInfoEntryRowFactory());
    this.routeInfoEntry = moFactory
      .createTable(oidRouteInfoEntry, this.routeInfoEntryIndex, 
      routeInfoEntryColumns, this.routeInfoEntryModel);
  }

  public MOTable<ProcResourceUsedEntryRow, MOColumn, MOTableModel<ProcResourceUsedEntryRow>> getProcResourceUsedEntry() {
    return this.procResourceUsedEntry;
  }

  private void createProcResourceUsedEntry(MOFactory moFactory)
  {
    this.procResourceUsedEntryIndexes = new MOTableSubIndex[] { moFactory
      .createSubIndex(oidPid, 2, 1, 1) };

    this.procResourceUsedEntryIndex = moFactory.createIndex(
      this.procResourceUsedEntryIndexes, false, 
      new MOTableIndexValidator() {
      public boolean isValidIndex(OID index) {
        boolean isValidIndex = true;

        return isValidIndex;
      }
    });
    MOColumn[] procResourceUsedEntryColumns = new MOColumn[4];
    procResourceUsedEntryColumns[0] = moFactory.createColumn(1, 
      65, 
      moFactory.createAccess(9));
    procResourceUsedEntryColumns[1] = moFactory.createColumn(
      2, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    procResourceUsedEntryColumns[2] = moFactory.createColumn(
      3, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    procResourceUsedEntryColumns[3] = moFactory.createColumn(
      4, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");

    this.procResourceUsedEntryModel = moFactory.createTableModel(
      oidProcResourceUsedEntry, this.procResourceUsedEntryIndex, 
      procResourceUsedEntryColumns);
    ((MOMutableTableModel)this.procResourceUsedEntryModel)
      .setRowFactory(new ProcResourceUsedEntryRowFactory());
    this.procResourceUsedEntry = moFactory.createTable(oidProcResourceUsedEntry, 
      this.procResourceUsedEntryIndex, procResourceUsedEntryColumns, 
      this.procResourceUsedEntryModel);
  }

  public MOTable<MsgAlarmEntryRow, MOColumn, MOTableModel<MsgAlarmEntryRow>> getMsgAlarmEntry() {
    return this.msgAlarmEntry;
  }

  private void createMsgAlarmEntry(MOFactory moFactory)
  {
    this.msgAlarmEntryIndexes = new MOTableSubIndex[] { moFactory
      .createSubIndex(oidMsgtype, 2, 1, 1) };

    this.msgAlarmEntryIndex = moFactory.createIndex(this.msgAlarmEntryIndexes, false, 
      new MOTableIndexValidator() {
      public boolean isValidIndex(OID index) {
        boolean isValidIndex = true;

        return isValidIndex;
      }
    });
    MOColumn[] msgAlarmEntryColumns = new MOColumn[3];
    msgAlarmEntryColumns[0] = moFactory.createColumn(1, 
      65, 
      moFactory.createAccess(9));
    msgAlarmEntryColumns[1] = moFactory.createColumn(
      2, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    msgAlarmEntryColumns[2] = moFactory.createColumn(
      3, 65, 
      moFactory.createAccess(9));

    this.msgAlarmEntryModel = moFactory.createTableModel(oidMsgAlarmEntry, 
      this.msgAlarmEntryIndex, msgAlarmEntryColumns);
    ((MOMutableTableModel)this.msgAlarmEntryModel)
      .setRowFactory(new MsgAlarmEntryRowFactory());
    this.msgAlarmEntry = moFactory.createTable(oidMsgAlarmEntry, 
      this.msgAlarmEntryIndex, msgAlarmEntryColumns, this.msgAlarmEntryModel);
  }

  public MOTable<FlowAlarmEntryRow, MOColumn, MOTableModel<FlowAlarmEntryRow>> getFlowAlarmEntry() {
    return this.flowAlarmEntry;
  }

  private void createFlowAlarmEntry(MOFactory moFactory)
  {
    this.flowAlarmEntryIndexes = new MOTableSubIndex[] { 
      moFactory.createSubIndex(oidFlowalertnecode, 
      4, 0, 255), 
      moFactory.createSubIndex(oidFlowalertuser, 
      4, 0, 255), 
      moFactory.createSubIndex(oidFLOWALERTCapability, 
      4, 0, 255) };

    this.flowAlarmEntryIndex = moFactory.createIndex(this.flowAlarmEntryIndexes, 
      false, new MOTableIndexValidator() {
      public boolean isValidIndex(OID index) {
        boolean isValidIndex = true;

        return isValidIndex;
      }
    });
    MOColumn[] flowAlarmEntryColumns = new MOColumn[7];
    flowAlarmEntryColumns[0] = moFactory.createColumn(
      1, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    flowAlarmEntryColumns[1] = moFactory.createColumn(
      2, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    flowAlarmEntryColumns[2] = moFactory.createColumn(
      3, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    flowAlarmEntryColumns[3] = moFactory.createColumn(
      4, 65, 
      moFactory.createAccess(9));
    flowAlarmEntryColumns[4] = moFactory.createColumn(
      5, 65, 
      moFactory.createAccess(9));
    flowAlarmEntryColumns[5] = moFactory.createColumn(
      6, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    flowAlarmEntryColumns[6] = moFactory.createColumn(
      7, 65, 
      moFactory.createAccess(9));

    this.flowAlarmEntryModel = moFactory.createTableModel(oidFlowAlarmEntry, 
      this.flowAlarmEntryIndex, flowAlarmEntryColumns);
    ((MOMutableTableModel)this.flowAlarmEntryModel)
      .setRowFactory(new FlowAlarmEntryRowFactory());
    this.flowAlarmEntry = moFactory
      .createTable(oidFlowAlarmEntry, this.flowAlarmEntryIndex, 
      flowAlarmEntryColumns, this.flowAlarmEntryModel);
  }

  public MOTable<OutNeLinkAlarmEntryRow, MOColumn, MOTableModel<OutNeLinkAlarmEntryRow>> getOutNeLinkAlarmEntry() {
    return this.outNeLinkAlarmEntry;
  }

  private void createOutNeLinkAlarmEntry(MOFactory moFactory)
  {
    this.outNeLinkAlarmEntryIndexes = new MOTableSubIndex[] { moFactory
      .createSubIndex(oidLinknecode, 2, 1, 
      1) };

    this.outNeLinkAlarmEntryIndex = moFactory.createIndex(
      this.outNeLinkAlarmEntryIndexes, false, new MOTableIndexValidator() {
      public boolean isValidIndex(OID index) {
        boolean isValidIndex = true;

        return isValidIndex;
      }
    });
    MOColumn[] outNeLinkAlarmEntryColumns = new MOColumn[4];
    outNeLinkAlarmEntryColumns[0] = moFactory.createColumn(
      1, 4, 
      moFactory.createAccess(9));
    outNeLinkAlarmEntryColumns[1] = moFactory.createColumn(
      2, 65, 
      moFactory.createAccess(9));
    outNeLinkAlarmEntryColumns[2] = moFactory.createColumn(
      3, 4, 
      moFactory.createAccess(9), 
      "SNMPv2-TC", "DisplayString");
    outNeLinkAlarmEntryColumns[3] = moFactory.createColumn(
      4, 65, 
      moFactory.createAccess(9));

    this.outNeLinkAlarmEntryModel = moFactory.createTableModel(
      oidOutNeLinkAlarmEntry, this.outNeLinkAlarmEntryIndex, 
      outNeLinkAlarmEntryColumns);
    ((MOMutableTableModel)this.outNeLinkAlarmEntryModel)
      .setRowFactory(new OutNeLinkAlarmEntryRowFactory());
    this.outNeLinkAlarmEntry = moFactory.createTable(oidOutNeLinkAlarmEntry, 
      this.outNeLinkAlarmEntryIndex, outNeLinkAlarmEntryColumns, 
      this.outNeLinkAlarmEntryModel);
  }

  public void registerMOs(MOServer server, OctetString context)
    throws DuplicateRegistrationException
  {
    server.register(this.neid, context);
    server.register(this.sgwid, context);
    server.register(this.nename, context);
    server.register(this.deployaddr, context);
    server.register(this.nEVendorName, context);
    server.register(this.neversion, context);
    server.register(this.nodeId, context);
    server.register(this.sgwbsnstate, context);
    server.register(this.sgwnestate, context);
    server.register(this.sgwsysuptime, context);
    server.register(this.sgwconlevel, context);
    server.register(this.neCpuRate, context);
    server.register(this.neMemRate, context);
    server.register(this.neQueSize, context);
    server.register(this.neQueRate, context);
    server.register(this.fileresult, context);
    server.register(this.fileupdatetime, context);
    server.register(this.maxconnections, context);
    server.register(this.linkalertupdatetime, context);
    server.register(this.oldlevel, context);
    server.register(this.newlevel, context);
    server.register(this.levelupdatetime, context);
    server.register(this.protocolInfoEntry, context);
    server.register(this.serviceInfoEntry, context);
    server.register(this.userInfoEntry, context);
    server.register(this.userServInfoEntry, context);
    server.register(this.routeInfoEntry, context);
    server.register(this.procResourceUsedEntry, context);
    server.register(this.msgAlarmEntry, context);
    server.register(this.flowAlarmEntry, context);
    server.register(this.outNeLinkAlarmEntry, context);
  }

  public void unregisterMOs(MOServer server, OctetString context)
  {
    server.unregister(this.neid, context);
    server.unregister(this.sgwid, context);
    server.unregister(this.nename, context);
    server.unregister(this.deployaddr, context);
    server.unregister(this.nEVendorName, context);
    server.unregister(this.neversion, context);
    server.unregister(this.nodeId, context);
    server.unregister(this.sgwbsnstate, context);
    server.unregister(this.sgwnestate, context);
    server.unregister(this.sgwsysuptime, context);
    server.unregister(this.sgwconlevel, context);
    server.unregister(this.neCpuRate, context);
    server.unregister(this.neMemRate, context);
    server.unregister(this.neQueSize, context);
    server.unregister(this.neQueRate, context);
    server.unregister(this.fileresult, context);
    server.unregister(this.fileupdatetime, context);
    server.unregister(this.maxconnections, context);
    server.unregister(this.linkalertupdatetime, context);
    server.unregister(this.oldlevel, context);
    server.unregister(this.newlevel, context);
    server.unregister(this.levelupdatetime, context);
    server.unregister(this.protocolInfoEntry, context);
    server.unregister(this.serviceInfoEntry, context);
    server.unregister(this.userInfoEntry, context);
    server.unregister(this.userServInfoEntry, context);
    server.unregister(this.routeInfoEntry, context);
    server.unregister(this.procResourceUsedEntry, context);
    server.unregister(this.msgAlarmEntry, context);
    server.unregister(this.flowAlarmEntry, context);
    server.unregister(this.outNeLinkAlarmEntry, context);
  }

  public void sGWStatesChanged(NotificationOriginator notificationOriginator, OctetString context, VariableBinding[] vbs)
  {
    if (vbs.length < 10) {
      throw new IllegalArgumentException("Too few notification objects: " + 
        vbs.length + "<10");
    }
    if (!vbs[0].getOid().startsWith(oidTrapVarNeid)) {
      throw new IllegalArgumentException("Variable 0 has wrong OID: " + 
        vbs[0].getOid() + " does not start with " + 
        oidTrapVarNeid);
    }
    if (!vbs[1].getOid().startsWith(oidTrapVarSgwid)) {
      throw new IllegalArgumentException("Variable 1 has wrong OID: " + 
        vbs[1].getOid() + " does not start with " + 
        oidTrapVarSgwid);
    }
    if (!vbs[2].getOid().startsWith(oidTrapVarNename)) {
      throw new IllegalArgumentException("Variable 2 has wrong OID: " + 
        vbs[2].getOid() + " does not start with " + 
        oidTrapVarNename);
    }
    if (!vbs[3].getOid().startsWith(oidTrapVarDeployaddr)) {
      throw new IllegalArgumentException("Variable 3 has wrong OID: " + 
        vbs[3].getOid() + " does not start with " + 
        oidTrapVarDeployaddr);
    }
    if (!vbs[4].getOid().startsWith(oidTrapVarNEVendorName)) {
      throw new IllegalArgumentException("Variable 4 has wrong OID: " + 
        vbs[4].getOid() + " does not start with " + 
        oidTrapVarNEVendorName);
    }
    if (!vbs[5].getOid().startsWith(oidTrapVarNeversion)) {
      throw new IllegalArgumentException("Variable 5 has wrong OID: " + 
        vbs[5].getOid() + " does not start with " + 
        oidTrapVarNeversion);
    }
    if (!vbs[6].getOid().startsWith(oidTrapVarNodeId)) {
      throw new IllegalArgumentException("Variable 6 has wrong OID: " + 
        vbs[6].getOid() + " does not start with " + 
        oidTrapVarNodeId);
    }
    if (!vbs[7].getOid().startsWith(oidTrapVarSgwbsnstate)) {
      throw new IllegalArgumentException("Variable 7 has wrong OID: " + 
        vbs[7].getOid() + " does not start with " + 
        oidTrapVarSgwbsnstate);
    }
    if (!vbs[8].getOid().startsWith(oidTrapVarSgwnestate)) {
      throw new IllegalArgumentException("Variable 8 has wrong OID: " + 
        vbs[8].getOid() + " does not start with " + 
        oidTrapVarSgwnestate);
    }
    if (!vbs[9].getOid().startsWith(oidTrapVarSgwsysuptime)) {
      throw new IllegalArgumentException("Variable 9 has wrong OID: " + 
        vbs[9].getOid() + " does not start with " + 
        oidTrapVarSgwsysuptime);
    }
    notificationOriginator.notify(context, oidSGWStatesChanged, vbs);
  }

  public void msgErrorNotify(NotificationOriginator notificationOriginator, OctetString context, VariableBinding[] vbs)
  {
    if (vbs.length < 3) {
      throw new IllegalArgumentException("Too few notification objects: " + 
        vbs.length + "<3");
    }
    if (!vbs[0].getOid().startsWith(oidTrapVarMsgtype)) {
      throw new IllegalArgumentException("Variable 0 has wrong OID: " + 
        vbs[0].getOid() + " does not start with " + 
        oidTrapVarMsgtype);
    }
    if (!this.msgAlarmEntryIndex.isValidIndex(this.msgAlarmEntry.getIndexPart(vbs[0]
      .getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 0 specified: " + 
        this.msgAlarmEntry.getIndexPart(vbs[0].getOid()));
    }
    if (!vbs[1].getOid().startsWith(oidTrapVarMsgerrresult)) {
      throw new IllegalArgumentException("Variable 1 has wrong OID: " + 
        vbs[1].getOid() + " does not start with " + 
        oidTrapVarMsgerrresult);
    }
    if (!this.msgAlarmEntryIndex.isValidIndex(this.msgAlarmEntry.getIndexPart(vbs[1]
      .getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 1 specified: " + 
        this.msgAlarmEntry.getIndexPart(vbs[1].getOid()));
    }
    if (!vbs[2].getOid().startsWith(oidTrapVarMsgupdatetime)) {
      throw new IllegalArgumentException("Variable 2 has wrong OID: " + 
        vbs[2].getOid() + " does not start with " + 
        oidTrapVarMsgupdatetime);
    }
    if (!this.msgAlarmEntryIndex.isValidIndex(this.msgAlarmEntry.getIndexPart(vbs[2]
      .getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 2 specified: " + 
        this.msgAlarmEntry.getIndexPart(vbs[2].getOid()));
    }
    notificationOriginator.notify(context, oidMsgErrorNotify, vbs);
  }

  public void fileErrorNotify(NotificationOriginator notificationOriginator, OctetString context, VariableBinding[] vbs)
  {
    if (vbs.length < 2) {
      throw new IllegalArgumentException("Too few notification objects: " + 
        vbs.length + "<2");
    }
    if (!vbs[0].getOid().startsWith(oidTrapVarFileresult)) {
      throw new IllegalArgumentException("Variable 0 has wrong OID: " + 
        vbs[0].getOid() + " does not start with " + 
        oidTrapVarFileresult);
    }
    if (!vbs[1].getOid().startsWith(oidTrapVarFileupdatetime)) {
      throw new IllegalArgumentException("Variable 1 has wrong OID: " + 
        vbs[1].getOid() + " does not start with " + 
        oidTrapVarFileupdatetime);
    }
    notificationOriginator.notify(context, oidFileErrorNotify, vbs);
  }

  public void interfaceConnectsCntMaxNotify(NotificationOriginator notificationOriginator, OctetString context, VariableBinding[] vbs)
  {
    if (vbs.length < 2) {
      throw new IllegalArgumentException("Too few notification objects: " + 
        vbs.length + "<2");
    }
    if (!vbs[0].getOid().startsWith(oidTrapVarMaxconnections)) {
      throw new IllegalArgumentException("Variable 0 has wrong OID: " + 
        vbs[0].getOid() + " does not start with " + 
        oidTrapVarMaxconnections);
    }
    if (!vbs[1].getOid().startsWith(oidTrapVarLinkalertupdatetime)) {
      throw new IllegalArgumentException("Variable 1 has wrong OID: " + 
        vbs[1].getOid() + " does not start with " + 
        oidTrapVarLinkalertupdatetime);
    }
    notificationOriginator.notify(context, 
      oidInterfaceConnectsCntMaxNotify, vbs);
  }

  public void flowSizeAlertNotify(NotificationOriginator notificationOriginator, OctetString context, VariableBinding[] vbs)
  {
    if (vbs.length < 7) {
      throw new IllegalArgumentException("Too few notification objects: " + 
        vbs.length + "<7");
    }
    if (!vbs[0].getOid().startsWith(oidTrapVarFlowalertnecode)) {
      throw new IllegalArgumentException("Variable 0 has wrong OID: " + 
        vbs[0].getOid() + " does not start with " + 
        oidTrapVarFlowalertnecode);
    }
    if (!this.flowAlarmEntryIndex.isValidIndex(this.flowAlarmEntry
      .getIndexPart(vbs[0].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 0 specified: " + 
        this.flowAlarmEntry.getIndexPart(vbs[0].getOid()));
    }
    if (!vbs[1].getOid().startsWith(oidTrapVarFlowalertuser)) {
      throw new IllegalArgumentException("Variable 1 has wrong OID: " + 
        vbs[1].getOid() + " does not start with " + 
        oidTrapVarFlowalertuser);
    }
    if (!this.flowAlarmEntryIndex.isValidIndex(this.flowAlarmEntry
      .getIndexPart(vbs[1].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 1 specified: " + 
        this.flowAlarmEntry.getIndexPart(vbs[1].getOid()));
    }
    if (!vbs[2].getOid().startsWith(oidTrapVarFLOWALERTCapability)) {
      throw new IllegalArgumentException("Variable 2 has wrong OID: " + 
        vbs[2].getOid() + " does not start with " + 
        oidTrapVarFLOWALERTCapability);
    }
    if (!this.flowAlarmEntryIndex.isValidIndex(this.flowAlarmEntry
      .getIndexPart(vbs[2].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 2 specified: " + 
        this.flowAlarmEntry.getIndexPart(vbs[2].getOid()));
    }
    if (!vbs[3].getOid().startsWith(oidTrapVarFLOWALERTFLOWCount)) {
      throw new IllegalArgumentException("Variable 3 has wrong OID: " + 
        vbs[3].getOid() + " does not start with " + 
        oidTrapVarFLOWALERTFLOWCount);
    }
    if (!this.flowAlarmEntryIndex.isValidIndex(this.flowAlarmEntry
      .getIndexPart(vbs[3].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 3 specified: " + 
        this.flowAlarmEntry.getIndexPart(vbs[3].getOid()));
    }
    if (!vbs[4].getOid().startsWith(oidTrapVarFlowalertflowszie)) {
      throw new IllegalArgumentException("Variable 4 has wrong OID: " + 
        vbs[4].getOid() + " does not start with " + 
        oidTrapVarFlowalertflowszie);
    }
    if (!this.flowAlarmEntryIndex.isValidIndex(this.flowAlarmEntry
      .getIndexPart(vbs[4].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 4 specified: " + 
        this.flowAlarmEntry.getIndexPart(vbs[4].getOid()));
    }
    if (!vbs[5].getOid().startsWith(oidTrapVarAlertreason)) {
      throw new IllegalArgumentException("Variable 5 has wrong OID: " + 
        vbs[5].getOid() + " does not start with " + 
        oidTrapVarAlertreason);
    }
    if (!this.flowAlarmEntryIndex.isValidIndex(this.flowAlarmEntry
      .getIndexPart(vbs[5].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 5 specified: " + 
        this.flowAlarmEntry.getIndexPart(vbs[5].getOid()));
    }
    if (!vbs[6].getOid().startsWith(oidTrapVarFlowalertupdatetime)) {
      throw new IllegalArgumentException("Variable 6 has wrong OID: " + 
        vbs[6].getOid() + " does not start with " + 
        oidTrapVarFlowalertupdatetime);
    }
    if (!this.flowAlarmEntryIndex.isValidIndex(this.flowAlarmEntry
      .getIndexPart(vbs[6].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 6 specified: " + 
        this.flowAlarmEntry.getIndexPart(vbs[6].getOid()));
    }
    notificationOriginator.notify(context, oidFlowSizeAlertNotify, vbs);
  }

  public void blockChangedNotify(NotificationOriginator notificationOriginator, OctetString context, VariableBinding[] vbs)
  {
    if (vbs.length < 3) {
      throw new IllegalArgumentException("Too few notification objects: " + 
        vbs.length + "<3");
    }
    if (!vbs[0].getOid().startsWith(oidTrapVarOldlevel)) {
      throw new IllegalArgumentException("Variable 0 has wrong OID: " + 
        vbs[0].getOid() + " does not start with " + 
        oidTrapVarOldlevel);
    }
    if (!vbs[1].getOid().startsWith(oidTrapVarNewlevel)) {
      throw new IllegalArgumentException("Variable 1 has wrong OID: " + 
        vbs[1].getOid() + " does not start with " + 
        oidTrapVarNewlevel);
    }
    if (!vbs[2].getOid().startsWith(oidTrapVarLevelupdatetime)) {
      throw new IllegalArgumentException("Variable 2 has wrong OID: " + 
        vbs[2].getOid() + " does not start with " + 
        oidTrapVarLevelupdatetime);
    }
    notificationOriginator.notify(context, oidBlockChangedNotify, vbs);
  }

  public void interfaceRunningErrorNotify(NotificationOriginator notificationOriginator, OctetString context, VariableBinding[] vbs)
  {
    if (vbs.length < 4) {
      throw new IllegalArgumentException("Too few notification objects: " + 
        vbs.length + "<4");
    }
    if (!vbs[0].getOid().startsWith(oidTrapVarLinknecode)) {
      throw new IllegalArgumentException("Variable 0 has wrong OID: " + 
        vbs[0].getOid() + " does not start with " + 
        oidTrapVarLinknecode);
    }
    if (!this.outNeLinkAlarmEntryIndex.isValidIndex(this.outNeLinkAlarmEntry
      .getIndexPart(vbs[0].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 0 specified: " + 
        this.outNeLinkAlarmEntry.getIndexPart(vbs[0].getOid()));
    }
    if (!vbs[1].getOid().startsWith(oidTrapVarLinkstate)) {
      throw new IllegalArgumentException("Variable 1 has wrong OID: " + 
        vbs[1].getOid() + " does not start with " + 
        oidTrapVarLinkstate);
    }
    if (!this.outNeLinkAlarmEntryIndex.isValidIndex(this.outNeLinkAlarmEntry
      .getIndexPart(vbs[1].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 1 specified: " + 
        this.outNeLinkAlarmEntry.getIndexPart(vbs[1].getOid()));
    }
    if (!vbs[2].getOid().startsWith(oidTrapVarLinkstatedesc)) {
      throw new IllegalArgumentException("Variable 2 has wrong OID: " + 
        vbs[2].getOid() + " does not start with " + 
        oidTrapVarLinkstatedesc);
    }
    if (!this.outNeLinkAlarmEntryIndex.isValidIndex(this.outNeLinkAlarmEntry
      .getIndexPart(vbs[2].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 2 specified: " + 
        this.outNeLinkAlarmEntry.getIndexPart(vbs[2].getOid()));
    }
    if (!vbs[3].getOid().startsWith(oidTrapVarLinkupdatetime)) {
      throw new IllegalArgumentException("Variable 3 has wrong OID: " + 
        vbs[3].getOid() + " does not start with " + 
        oidTrapVarLinkupdatetime);
    }
    if (!this.outNeLinkAlarmEntryIndex.isValidIndex(this.outNeLinkAlarmEntry
      .getIndexPart(vbs[3].getOid()))) {
      throw new IllegalArgumentException(
        "Illegal index for variable 3 specified: " + 
        this.outNeLinkAlarmEntry.getIndexPart(vbs[3].getOid()));
    }
    notificationOriginator.notify(context, oidInterfaceRunningErrorNotify, 
      vbs);
  }

  protected void addTCsToFactory(MOFactory moFactory)
  {
  }

  public void addImportedTCsToFactory(MOFactory moFactory)
  {
  }

  public class FlowAlarmEntryRow extends DefaultMOMutableRow2PC
  {
    public FlowAlarmEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public OctetString getFlowalertnecode()
    {
      return (OctetString)super.getValue(0);
    }

    public void setFlowalertnecode(OctetString newValue)
    {
      super.setValue(0, newValue);
    }

    public OctetString getFlowalertuser()
    {
      return (OctetString)super.getValue(1);
    }

    public void setFlowalertuser(OctetString newValue)
    {
      super.setValue(1, newValue);
    }

    public OctetString getFLOWALERTCapability()
    {
      return (OctetString)super.getValue(2);
    }

    public void setFLOWALERTCapability(OctetString newValue)
    {
      super.setValue(2, newValue);
    }

    public Counter32 getFLOWALERTFLOWCount()
    {
      return (Counter32)super.getValue(3);
    }

    public void setFLOWALERTFLOWCount(Counter32 newValue)
    {
      super.setValue(3, newValue);
    }

    public Counter32 getFlowalertflowszie()
    {
      return (Counter32)super.getValue(4);
    }

    public void setFlowalertflowszie(Counter32 newValue)
    {
      super.setValue(4, newValue);
    }

    public OctetString getAlertreason()
    {
      return (OctetString)super.getValue(5);
    }

    public void setAlertreason(OctetString newValue)
    {
      super.setValue(5, newValue);
    }

    public Counter32 getFlowalertupdatetime()
    {
      return (Counter32)super.getValue(6);
    }

    public void setFlowalertupdatetime(Counter32 newValue)
    {
      super.setValue(6, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getFlowalertnecode();
      case 1:
        return getFlowalertuser();
      case 2:
        return getFLOWALERTCapability();
      case 3:
        return getFLOWALERTFLOWCount();
      case 4:
        return getFlowalertflowszie();
      case 5:
        return getAlertreason();
      case 6:
        return getFlowalertupdatetime();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setFlowalertnecode((OctetString)value);
        break;
      case 1:
        setFlowalertuser((OctetString)value);
        break;
      case 2:
        setFLOWALERTCapability((OctetString)value);
        break;
      case 3:
        setFLOWALERTFLOWCount((Counter32)value);
        break;
      case 4:
        setFlowalertflowszie((Counter32)value);
        break;
      case 5:
        setAlertreason((OctetString)value);
        break;
      case 6:
        setFlowalertupdatetime((Counter32)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class FlowAlarmEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.FlowAlarmEntryRow>
  {
    FlowAlarmEntryRowFactory()
    {
    }

    public synchronized SgwMib.FlowAlarmEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      FlowAlarmEntryRow row = new FlowAlarmEntryRow(index, values);

      return row;
    }

    public synchronized void freeRow(SgwMib.FlowAlarmEntryRow row)
    {
    }
  }

  public class MsgAlarmEntryRow extends DefaultMOMutableRow2PC
  {
    public MsgAlarmEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public Counter32 getMsgtype()
    {
      return (Counter32)super.getValue(0);
    }

    public void setMsgtype(Counter32 newValue)
    {
      super.setValue(0, newValue);
    }

    public OctetString getMsgerrresult()
    {
      return (OctetString)super.getValue(1);
    }

    public void setMsgerrresult(OctetString newValue)
    {
      super.setValue(1, newValue);
    }

    public Counter32 getMsgupdatetime()
    {
      return (Counter32)super.getValue(2);
    }

    public void setMsgupdatetime(Counter32 newValue)
    {
      super.setValue(2, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getMsgtype();
      case 1:
        return getMsgerrresult();
      case 2:
        return getMsgupdatetime();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setMsgtype((Counter32)value);
        break;
      case 1:
        setMsgerrresult((OctetString)value);
        break;
      case 2:
        setMsgupdatetime((Counter32)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class MsgAlarmEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.MsgAlarmEntryRow>
  {
    MsgAlarmEntryRowFactory()
    {
    }

    public synchronized SgwMib.MsgAlarmEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      SgwMib.MsgAlarmEntryRow row = new SgwMib.MsgAlarmEntryRow(index, values);

      return row;
    }

    public synchronized void freeRow(SgwMib.MsgAlarmEntryRow row)
    {
    }
  }

  public class OutNeLinkAlarmEntryRow extends DefaultMOMutableRow2PC
  {
    public OutNeLinkAlarmEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public Counter32 getLinknecode()
    {
      return (Counter32)super.getValue(0);
    }

    public void setLinknecode(Counter32 newValue)
    {
      super.setValue(0, newValue);
    }

    public Counter32 getLinkstate()
    {
      return (Counter32)super.getValue(1);
    }

    public void setLinkstate(Counter32 newValue)
    {
      super.setValue(1, newValue);
    }

    public OctetString getLinkstatedesc()
    {
      return (OctetString)super.getValue(2);
    }

    public void setLinkstatedesc(OctetString newValue)
    {
      super.setValue(2, newValue);
    }

    public Counter32 getLinkupdatetime()
    {
      return (Counter32)super.getValue(3);
    }

    public void setLinkupdatetime(Counter32 newValue)
    {
      super.setValue(3, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getLinknecode();
      case 1:
        return getLinkstate();
      case 2:
        return getLinkstatedesc();
      case 3:
        return getLinkupdatetime();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setLinknecode((Counter32)value);
        break;
      case 1:
        setLinkstate((Counter32)value);
        break;
      case 2:
        setLinkstatedesc((OctetString)value);
        break;
      case 3:
        setLinkupdatetime((Counter32)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class OutNeLinkAlarmEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.OutNeLinkAlarmEntryRow>
  {
    OutNeLinkAlarmEntryRowFactory()
    {
    }

    public synchronized SgwMib.OutNeLinkAlarmEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      SgwMib.OutNeLinkAlarmEntryRow row = new SgwMib.OutNeLinkAlarmEntryRow(index, 
        values);

      return row;
    }

    public synchronized void freeRow(SgwMib.OutNeLinkAlarmEntryRow row)
    {
    }
  }

  public class ProcResourceUsedEntryRow extends DefaultMOMutableRow2PC
  {
    public ProcResourceUsedEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public Counter32 getPid()
    {
      return (Counter32)super.getValue(0);
    }

    public void setPid(Counter32 newValue)
    {
      super.setValue(0, newValue);
    }

    public OctetString getPname()
    {
      return (OctetString)super.getValue(1);
    }

    public void setPname(OctetString newValue)
    {
      super.setValue(1, newValue);
    }

    public OctetString getPCpuRate()
    {
      return (OctetString)super.getValue(2);
    }

    public void setPCpuRate(OctetString newValue)
    {
      super.setValue(2, newValue);
    }

    public OctetString getPMemRate()
    {
      return (OctetString)super.getValue(3);
    }

    public void setPMemRate(OctetString newValue)
    {
      super.setValue(3, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getPid();
      case 1:
        return getPname();
      case 2:
        return getPCpuRate();
      case 3:
        return getPMemRate();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setPid((Counter32)value);
        break;
      case 1:
        setPname((OctetString)value);
        break;
      case 2:
        setPCpuRate((OctetString)value);
        break;
      case 3:
        setPMemRate((OctetString)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class ProcResourceUsedEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.ProcResourceUsedEntryRow>
  {
    ProcResourceUsedEntryRowFactory()
    {
    }

    public synchronized SgwMib.ProcResourceUsedEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      SgwMib.ProcResourceUsedEntryRow row = new SgwMib.ProcResourceUsedEntryRow(index, 
        values);

      return row;
    }

    public synchronized void freeRow(SgwMib.ProcResourceUsedEntryRow row)
    {
    }
  }

  public class ProtocolInfoEntryRow extends DefaultMOMutableRow2PC
  {
    public ProtocolInfoEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public Counter32 getProtocolcode()
    {
      return (Counter32)super.getValue(0);
    }

    public void setProtocolcode(Counter32 newValue)
    {
      super.setValue(0, newValue);
    }

    public OctetString getProtocolname()
    {
      return (OctetString)super.getValue(1);
    }

    public void setProtocolname(OctetString newValue)
    {
      super.setValue(1, newValue);
    }

    public OctetString getProtocolversion()
    {
      return (OctetString)super.getValue(2);
    }

    public void setProtocolversion(OctetString newValue)
    {
      super.setValue(2, newValue);
    }

    public OctetString getProtocoldesc()
    {
      return (OctetString)super.getValue(3);
    }

    public void setProtocoldesc(OctetString newValue)
    {
      super.setValue(3, newValue);
    }

    public Counter32 getTimeoutLinkWait()
    {
      return (Counter32)super.getValue(4);
    }

    public void setTimeoutLinkWait(Counter32 newValue)
    {
      super.setValue(4, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getProtocolcode();
      case 1:
        return getProtocolname();
      case 2:
        return getProtocolversion();
      case 3:
        return getProtocoldesc();
      case 4:
        return getTimeoutLinkWait();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setProtocolcode((Counter32)value);
        break;
      case 1:
        setProtocolname((OctetString)value);
        break;
      case 2:
        setProtocolversion((OctetString)value);
        break;
      case 3:
        setProtocoldesc((OctetString)value);
        break;
      case 4:
        setTimeoutLinkWait((Counter32)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class ProtocolInfoEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.ProtocolInfoEntryRow>
  {
    ProtocolInfoEntryRowFactory()
    {
    }

    public synchronized SgwMib.ProtocolInfoEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      SgwMib.ProtocolInfoEntryRow row = new SgwMib.ProtocolInfoEntryRow(index, values);

      return row;
    }

    public synchronized void freeRow(SgwMib.ProtocolInfoEntryRow row)
    {
    }
  }

  public class RouteInfoEntryRow extends DefaultMOMutableRow2PC
  {
    public RouteInfoEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public Counter32 getSrid()
    {
      return (Counter32)super.getValue(0);
    }

    public void setSrid(Counter32 newValue)
    {
      super.setValue(0, newValue);
    }

    public OctetString getIp()
    {
      return (OctetString)super.getValue(1);
    }

    public void setIp(OctetString newValue)
    {
      super.setValue(1, newValue);
    }

    public Counter32 getPort()
    {
      return (Counter32)super.getValue(2);
    }

    public void setPort(Counter32 newValue)
    {
      super.setValue(2, newValue);
    }

    public OctetString getName()
    {
      return (OctetString)super.getValue(3);
    }

    public void setName(OctetString newValue)
    {
      super.setValue(3, newValue);
    }

    public OctetString getRealm()
    {
      return (OctetString)super.getValue(4);
    }

    public void setRealm(OctetString newValue)
    {
      super.setValue(4, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getSrid();
      case 1:
        return getIp();
      case 2:
        return getPort();
      case 3:
        return getName();
      case 4:
        return getRealm();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setSrid((Counter32)value);
        break;
      case 1:
        setIp((OctetString)value);
        break;
      case 2:
        setPort((Counter32)value);
        break;
      case 3:
        setName((OctetString)value);
        break;
      case 4:
        setRealm((OctetString)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class RouteInfoEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.RouteInfoEntryRow>
  {
    RouteInfoEntryRowFactory()
    {
    }

    public synchronized SgwMib.RouteInfoEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      SgwMib.RouteInfoEntryRow row = new SgwMib.RouteInfoEntryRow(index, values);

      return row;
    }

    public synchronized void freeRow(SgwMib.RouteInfoEntryRow row)
    {
    }
  }

  public class ServiceInfoEntryRow extends DefaultMOMutableRow2PC
  {
    public ServiceInfoEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public Counter32 getServiceid()
    {
      return (Counter32)super.getValue(0);
    }

    public void setServiceid(Counter32 newValue)
    {
      super.setValue(0, newValue);
    }

    public OctetString getCapabilitycode()
    {
      return (OctetString)super.getValue(1);
    }

    public void setCapabilitycode(OctetString newValue)
    {
      super.setValue(1, newValue);
    }

    public OctetString getServicename()
    {
      return (OctetString)super.getValue(2);
    }

    public void setServicename(OctetString newValue)
    {
      super.setValue(2, newValue);
    }

    public OctetString getServicedesc()
    {
      return (OctetString)super.getValue(3);
    }

    public void setServicedesc(OctetString newValue)
    {
      super.setValue(3, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getServiceid();
      case 1:
        return getCapabilitycode();
      case 2:
        return getServicename();
      case 3:
        return getServicedesc();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setServiceid((Counter32)value);
        break;
      case 1:
        setCapabilitycode((OctetString)value);
        break;
      case 2:
        setServicename((OctetString)value);
        break;
      case 3:
        setServicedesc((OctetString)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class ServiceInfoEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.ServiceInfoEntryRow>
  {
    ServiceInfoEntryRowFactory()
    {
    }

    public synchronized SgwMib.ServiceInfoEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      SgwMib.ServiceInfoEntryRow row = new SgwMib.ServiceInfoEntryRow(index, values);

      return row;
    }

    public synchronized void freeRow(SgwMib.ServiceInfoEntryRow row)
    {
    }
  }

  public class UserInfoEntryRow extends DefaultMOMutableRow2PC
  {
    public UserInfoEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public OctetString getCfgusercode()
    {
      return (OctetString)super.getValue(0);
    }

    public void setCfgusercode(OctetString newValue)
    {
      super.setValue(0, newValue);
    }

    public OctetString getCfgusername()
    {
      return (OctetString)super.getValue(1);
    }

    public void setCfgusername(OctetString newValue)
    {
      super.setValue(1, newValue);
    }

    public OctetString getCfgnename()
    {
      return (OctetString)super.getValue(2);
    }

    public void setCfgnename(OctetString newValue)
    {
      super.setValue(2, newValue);
    }

    public OctetString getCfgnedesc()
    {
      return (OctetString)super.getValue(3);
    }

    public void setCfgnedesc(OctetString newValue)
    {
      super.setValue(3, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getCfgusercode();
      case 1:
        return getCfgusername();
      case 2:
        return getCfgnename();
      case 3:
        return getCfgnedesc();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setCfgusercode((OctetString)value);
        break;
      case 1:
        setCfgusername((OctetString)value);
        break;
      case 2:
        setCfgnename((OctetString)value);
        break;
      case 3:
        setCfgnedesc((OctetString)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class UserInfoEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.UserInfoEntryRow>
  {
    UserInfoEntryRowFactory()
    {
    }

    public synchronized SgwMib.UserInfoEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      SgwMib.UserInfoEntryRow row = new SgwMib.UserInfoEntryRow(index, values);

      return row;
    }

    public synchronized void freeRow(SgwMib.UserInfoEntryRow row)
    {
    }
  }

  public class UserServInfoEntryRow extends DefaultMOMutableRow2PC
  {
    public UserServInfoEntryRow(OID index, Variable[] values)
    {
      super(index,values);
    }

    public Counter32 getUseSvIdID()
    {
      return (Counter32)super.getValue(0);
    }

    public void setUseSvIdID(Counter32 newValue)
    {
      super.setValue(0, newValue);
    }

    public OctetString getSvrusercode()
    {
      return (OctetString)super.getValue(1);
    }

    public void setSvrusercode(OctetString newValue)
    {
      super.setValue(1, newValue);
    }

    public OctetString getUsercapabilitycode()
    {
      return (OctetString)super.getValue(2);
    }

    public void setUsercapabilitycode(OctetString newValue)
    {
      super.setValue(2, newValue);
    }

    public Variable getValue(int column)
    {
      switch (column) {
      case 0:
        return getUseSvIdID();
      case 1:
        return getSvrusercode();
      case 2:
        return getUsercapabilitycode();
      }
      return super.getValue(column);
    }

    public void setValue(int column, Variable value)
    {
      switch (column) {
      case 0:
        setUseSvIdID((Counter32)value);
        break;
      case 1:
        setSvrusercode((OctetString)value);
        break;
      case 2:
        setUsercapabilitycode((OctetString)value);
        break;
      default:
        super.setValue(column, value);
      }
    }
  }

  class UserServInfoEntryRowFactory extends DefaultMOMutableRow2PCFactory<SgwMib.UserServInfoEntryRow>
  {
    UserServInfoEntryRowFactory()
    {
    }

    public synchronized SgwMib.UserServInfoEntryRow createRow(OID index, Variable[] values) throws UnsupportedOperationException {
      SgwMib.UserServInfoEntryRow row = new SgwMib.UserServInfoEntryRow(index, values);

      return row;
    }

    public synchronized void freeRow(SgwMib.UserServInfoEntryRow row)
    {
    }
  }
}